{
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3",
   "language": "python"
  },
  "language_info": {
   "name": "python",
   "version": "3.10.13",
   "mimetype": "text/x-python",
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "pygments_lexer": "ipython3",
   "nbconvert_exporter": "python",
   "file_extension": ".py"
  },
  "kaggle": {
   "accelerator": "nvidiaTeslaT4",
   "dataSources": [],
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook",
   "isGpuEnabled": true
  }
 },
 "nbformat_minor": 4,
 "nbformat": 4,
 "cells": [
  {
   "cell_type": "code",
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n",
    "torch.manual_seed(seed)\n",
    "torch.cuda.manual_seed_all(seed)\n"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:31:44.936725Z",
     "start_time": "2024-05-02T08:31:40.034353600Z"
    },
    "execution": {
     "iopub.status.busy": "2024-05-03T04:47:12.527334Z",
     "iopub.execute_input": "2024-05-03T04:47:12.527802Z",
     "iopub.status.idle": "2024-05-03T04:47:17.362854Z",
     "shell.execute_reply.started": "2024-05-03T04:47:12.527757Z",
     "shell.execute_reply": "2024-05-03T04:47:17.361864Z"
    },
    "trusted": true
   },
   "execution_count": 1,
   "outputs": [
    {
     "name": "stdout",
     "text": "sys.version_info(major=3, minor=10, micro=13, releaselevel='final', serial=0)\nmatplotlib 3.7.5\nnumpy 1.26.4\npandas 2.2.2\nsklearn 1.2.2\ntorch 2.1.2\ncuda:0\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 准备数据"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "from tensorflow import keras\n",
    "#用karas有的数据集imdb，电影分类,分电影是积极的，还是消极的\n",
    "imdb = keras.datasets.imdb\n",
    "#载入数据使用下面两个参数\n",
    "vocab_size = 10000  #词典大小，仅保留训练数据中前10000个最经常出现的单词，低频单词被舍弃\n",
    "index_from = 3  #0,1,2,3空出来做别的事\n",
    "#前一万个词出现词频最高的会保留下来进行处理，后面的作为特殊字符处理，\n",
    "# 小于3的id都是特殊字符，下面代码有写\n",
    "# 需要注意的一点是取出来的词表还是从1开始的，需要做处理\n",
    "(train_data, train_labels), (test_data, test_labels) = imdb.load_data(\n",
    "    num_words = vocab_size, index_from = index_from)"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:32:04.220762800Z",
     "start_time": "2024-05-02T08:31:48.083348400Z"
    },
    "execution": {
     "iopub.status.busy": "2024-05-03T04:47:17.364755Z",
     "iopub.execute_input": "2024-05-03T04:47:17.365247Z",
     "iopub.status.idle": "2024-05-03T04:47:34.391998Z",
     "shell.execute_reply.started": "2024-05-03T04:47:17.365218Z",
     "shell.execute_reply": "2024-05-03T04:47:34.391210Z"
    },
    "trusted": true
   },
   "execution_count": 2,
   "outputs": [
    {
     "name": "stderr",
     "text": "2024-05-03 04:47:19.154174: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n2024-05-03 04:47:19.154307: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n2024-05-03 04:47:19.280829: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
     "output_type": "stream"
    },
    {
     "name": "stdout",
     "text": "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb.npz\n\u001B[1m17464789/17464789\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m0s\u001B[0m 0us/step\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "\n",
    "print(\"train\", len(train_data), train_labels.shape)  #25000个样本，每个样本是一段话，每个单词用一个数字表示\n",
    "print(\"test\", len(test_data), test_labels.shape)"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:32:14.425129500Z",
     "start_time": "2024-05-02T08:32:14.402142900Z"
    },
    "execution": {
     "iopub.status.busy": "2024-05-03T04:47:34.393563Z",
     "iopub.execute_input": "2024-05-03T04:47:34.394093Z",
     "iopub.status.idle": "2024-05-03T04:47:34.399413Z",
     "shell.execute_reply.started": "2024-05-03T04:47:34.394068Z",
     "shell.execute_reply": "2024-05-03T04:47:34.398409Z"
    },
    "trusted": true
   },
   "execution_count": 3,
   "outputs": [
    {
     "name": "stdout",
     "text": "train 25000 (25000,)\ntest 25000 (25000,)\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "#载入词表，看下词表长度，词表就像英语字典\n",
    "word_index = imdb.get_word_index()\n",
    "print(len(word_index))\n",
    "print(type(word_index))\n",
    "#词表虽然有8万多，但是我们只载入了最高频的1万词！！！！"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:32:17.066012200Z",
     "start_time": "2024-05-02T08:32:16.837139900Z"
    },
    "execution": {
     "iopub.status.busy": "2024-05-03T04:47:34.402571Z",
     "iopub.execute_input": "2024-05-03T04:47:34.403158Z",
     "iopub.status.idle": "2024-05-03T04:47:34.535124Z",
     "shell.execute_reply.started": "2024-05-03T04:47:34.403131Z",
     "shell.execute_reply": "2024-05-03T04:47:34.534127Z"
    },
    "trusted": true
   },
   "execution_count": 4,
   "outputs": [
    {
     "name": "stdout",
     "text": "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb_word_index.json\n\u001B[1m1641221/1641221\u001B[0m \u001B[32m━━━━━━━━━━━━━━━━━━━━\u001B[0m\u001B[37m\u001B[0m \u001B[1m0s\u001B[0m 0us/step\n88584\n<class 'dict'>\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 构造 word2idx 和 idx2word"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "word2idx = {word: idx + 3 for word, idx in word_index.items()}\n",
    "word2idx.update({\n",
    "    \"[PAD]\": 0,     # 填充 token\n",
    "    \"[BOS]\": 1,     # begin of sentence\n",
    "    \"[UNK]\": 2,     # 未知 token\n",
    "    \"[EOS]\": 3,     # end of sentence\n",
    "})\n",
    "\n",
    "idx2word = {idx: word for word, idx in word2idx.items()}"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:32:20.506027300Z",
     "start_time": "2024-05-02T08:32:20.420076700Z"
    },
    "execution": {
     "iopub.status.busy": "2024-05-03T04:47:34.536374Z",
     "iopub.execute_input": "2024-05-03T04:47:34.536752Z",
     "iopub.status.idle": "2024-05-03T04:47:34.579550Z",
     "shell.execute_reply.started": "2024-05-03T04:47:34.536716Z",
     "shell.execute_reply": "2024-05-03T04:47:34.578607Z"
    },
    "trusted": true
   },
   "execution_count": 5,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "# 选择 max_length\n",
    "length_collect = {}\n",
    "for text in train_data:\n",
    "    length = len(text)\n",
    "    length_collect[length] = length_collect.get(length, 0) + 1\n",
    "    \n",
    "MAX_LENGTH = 500\n",
    "plt.bar(length_collect.keys(), length_collect.values())\n",
    "plt.axvline(MAX_LENGTH, label=\"max length\", c=\"gray\", ls=\":\")\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-05-03T04:47:34.580697Z",
     "iopub.execute_input": "2024-05-03T04:47:34.581037Z",
     "iopub.status.idle": "2024-05-03T04:47:36.765733Z",
     "shell.execute_reply.started": "2024-05-03T04:47:34.581009Z",
     "shell.execute_reply": "2024-05-03T04:47:36.764837Z"
    },
    "trusted": true
   },
   "execution_count": 6,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {}
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Tokenizer"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "class Tokenizer:\n",
    "    def __init__(self, word2idx, idx2word, max_length=500, pad_idx=0, bos_idx=1, eos_idx=3, unk_idx=2):\n",
    "        self.word2idx = word2idx\n",
    "        self.idx2word = idx2word\n",
    "        self.max_length = max_length\n",
    "        self.pad_idx = pad_idx\n",
    "        self.bos_idx = bos_idx\n",
    "        self.eos_idx = eos_idx\n",
    "        self.unk_idx = unk_idx\n",
    "    \n",
    "    def encode(self, text_list, padding_first=False):\n",
    "        \"\"\"如果padding_first == True，则padding加载前面，否则加载后面\"\"\"\n",
    "        max_length = min(self.max_length, 2 + max([len(text) for text in text_list]))\n",
    "        indices_list = []\n",
    "        for text in text_list:\n",
    "            indices = [self.bos_idx] + [self.word2idx.get(word, self.unk_idx) for word in text[:max_length-2]] + [self.eos_idx]\n",
    "            if padding_first:\n",
    "                indices = [self.pad_idx] * (max_length - len(indices)) + indices\n",
    "            else:\n",
    "                indices = indices + [self.pad_idx] * (max_length - len(indices))\n",
    "            indices_list.append(indices)\n",
    "        return torch.tensor(indices_list)\n",
    "    \n",
    "    \n",
    "    def decode(self, indices_list, remove_bos=True, remove_eos=True, remove_pad=True, split=False):\n",
    "        text_list = []\n",
    "        for indices in indices_list:\n",
    "            text = []\n",
    "            for index in indices:\n",
    "                word = self.idx2word.get(index, \"[UNK]\")\n",
    "                if remove_bos and word == \"[BOS]\":\n",
    "                    continue\n",
    "                if remove_eos and word == \"[EOS]\":\n",
    "                    break\n",
    "                if remove_pad and word == \"[PAD]\":\n",
    "                    break\n",
    "                text.append(word)\n",
    "            text_list.append(\" \".join(text) if not split else text)\n",
    "        return text_list\n",
    "    \n",
    "\n",
    "tokenizer = Tokenizer(word2idx=word2idx, idx2word=idx2word)\n",
    "raw_text = [\"hello world\".split(), \"tokenize text datas with batch\".split(), \"this is a test\".split()]\n",
    "indices = tokenizer.encode(raw_text, padding_first=True)\n",
    "decode_text = tokenizer.decode(indices.tolist(), remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "print(\"raw text\")\n",
    "for raw in raw_text:\n",
    "    print(raw)\n",
    "print(\"indices\")\n",
    "for index in indices:\n",
    "    print(index)\n",
    "print(\"decode text\")\n",
    "for decode in decode_text:\n",
    "    print(decode)"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:32:28.841714100Z",
     "start_time": "2024-05-02T08:32:28.818725300Z"
    },
    "execution": {
     "iopub.status.busy": "2024-05-03T04:47:36.767290Z",
     "iopub.execute_input": "2024-05-03T04:47:36.767595Z",
     "iopub.status.idle": "2024-05-03T04:47:36.811355Z",
     "shell.execute_reply.started": "2024-05-03T04:47:36.767569Z",
     "shell.execute_reply": "2024-05-03T04:47:36.810435Z"
    },
    "trusted": true
   },
   "execution_count": 7,
   "outputs": [
    {
     "name": "stdout",
     "text": "raw text\n['hello', 'world']\n['tokenize', 'text', 'datas', 'with', 'batch']\n['this', 'is', 'a', 'test']\nindices\ntensor([   0,    0,    0,    1, 4825,  182,    3])\ntensor([    1,     2,  3004,     2,    19, 19233,     3])\ntensor([   0,    1,   14,    9,    6, 2181,    3])\ndecode text\n[PAD] [PAD] [PAD] [BOS] hello world [EOS]\n[BOS] [UNK] text [UNK] with batch [EOS]\n[PAD] [BOS] this is a test [EOS]\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "# 看看训练集的数据\n",
    "\n",
    "tokenizer.decode(train_data[:2], remove_bos=False, remove_eos=False, remove_pad=False)"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-05-03T04:47:36.812516Z",
     "iopub.execute_input": "2024-05-03T04:47:36.812799Z",
     "iopub.status.idle": "2024-05-03T04:47:36.819435Z",
     "shell.execute_reply.started": "2024-05-03T04:47:36.812774Z",
     "shell.execute_reply": "2024-05-03T04:47:36.818339Z"
    },
    "trusted": true
   },
   "execution_count": 8,
   "outputs": [
    {
     "execution_count": 8,
     "output_type": "execute_result",
     "data": {
      "text/plain": "[\"[BOS] this film was just brilliant casting location scenery story direction everyone's really suited the part they played and you could just imagine being there robert [UNK] is an amazing actor and now the same being director [UNK] father came from the same scottish island as myself so i loved the fact there was a real connection with this film the witty remarks throughout the film were great it was just brilliant so much that i bought the film as soon as it was released for [UNK] and would recommend it to everyone to watch and the fly fishing was amazing really cried at the end it was so sad and you know what they say if you cry at a film it must have been good and this definitely was also [UNK] to the two little boy's that played the [UNK] of norman and paul they were just brilliant children are often left out of the [UNK] list i think because the stars that play them all grown up are such a big profile for the whole film but these children are amazing and should be praised for what they have done don't you think the whole story was so lovely because it was true and was someone's life after all that was shared with us all\",\n \"[BOS] big hair big boobs bad music and a giant safety pin these are the words to best describe this terrible movie i love cheesy horror movies and i've seen hundreds but this had got to be on of the worst ever made the plot is paper thin and ridiculous the acting is an abomination the script is completely laughable the best is the end showdown with the cop and how he worked out who the killer is it's just so damn terribly written the clothes are sickening and funny in equal [UNK] the hair is big lots of boobs [UNK] men wear those cut [UNK] shirts that show off their [UNK] sickening that men actually wore them and the music is just [UNK] trash that plays over and over again in almost every scene there is trashy music boobs and [UNK] taking away bodies and the gym still doesn't close for [UNK] all joking aside this is a truly bad film whose only charm is to look back on the disaster that was the 80's and have a good old laugh at how bad everything was back then\"]"
     },
     "metadata": {}
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 数据集与 DataLoader"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "class IMDBDataset(Dataset):\n",
    "    def __init__(self, data, labels, remain_length=True):\n",
    "        if remain_length:\n",
    "            self.data = tokenizer.decode(data, remove_bos=False, remove_eos=False, remove_pad=False)\n",
    "        else:\n",
    "            # 缩减一下数据\n",
    "            self.data = tokenizer.decode(data)\n",
    "        self.labels = labels\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        text = self.data[index]\n",
    "        label = self.labels[index]\n",
    "        return text, label\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "    \n",
    "    \n",
    "def collate_fct(batch):\n",
    "    text_list = [item[0].split() for item in batch]\n",
    "    label_list = [item[1] for item in batch]\n",
    "    # 这里使用 padding first\n",
    "    text_list = tokenizer.encode(text_list, padding_first=True).to(dtype=torch.int)\n",
    "    return text_list, torch.tensor(label_list).reshape(-1, 1).to(dtype=torch.float)\n",
    "\n",
    "\n",
    "# 用RNN，缩短序列长度\n",
    "train_ds = IMDBDataset(train_data, train_labels, remain_length=False)\n",
    "test_ds = IMDBDataset(test_data, test_labels, remain_length=False)"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:32:41.820591900Z",
     "start_time": "2024-05-02T08:32:36.227566100Z"
    },
    "execution": {
     "iopub.status.busy": "2024-05-03T04:47:36.820601Z",
     "iopub.execute_input": "2024-05-03T04:47:36.820915Z",
     "iopub.status.idle": "2024-05-03T04:47:42.935725Z",
     "shell.execute_reply.started": "2024-05-03T04:47:36.820890Z",
     "shell.execute_reply": "2024-05-03T04:47:42.934882Z"
    },
    "trusted": true
   },
   "execution_count": 9,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "batch_size = 128\n",
    "train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True, collate_fn=collate_fct)\n",
    "test_dl = DataLoader(test_ds, batch_size=batch_size, shuffle=False, collate_fn=collate_fct)"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:33:12.220977300Z",
     "start_time": "2024-05-02T08:33:12.195716900Z"
    },
    "execution": {
     "iopub.status.busy": "2024-05-03T04:47:42.940057Z",
     "iopub.execute_input": "2024-05-03T04:47:42.940354Z",
     "iopub.status.idle": "2024-05-03T04:47:42.945758Z",
     "shell.execute_reply.started": "2024-05-03T04:47:42.940327Z",
     "shell.execute_reply": "2024-05-03T04:47:42.944620Z"
    },
    "trusted": true
   },
   "execution_count": 10,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 定义模型"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "class LSTM(nn.Module):\n",
    "    def __init__(self, embedding_dim=16, hidden_dim=64, vocab_size=vocab_size, num_layers=1, bidirectional=False):\n",
    "        super(LSTM, self).__init__()\n",
    "        self.embeding = nn.Embedding(vocab_size, embedding_dim)\n",
    "        self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers=num_layers, batch_first=True, bidirectional=bidirectional)\n",
    "        self.layer = nn.Linear(hidden_dim * (2 if bidirectional else 1), hidden_dim)\n",
    "        self.fc = nn.Linear(hidden_dim, 1)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # [bs, seq length]\n",
    "        x = self.embeding(x)\n",
    "        # [bs, seq length, embedding_dim] -> shape [bs, embedding_dim, seq length]\n",
    "        seq_output, (hidden, cell) = self.lstm(x)\n",
    "        # [bs, seq length, hidden_dim], [*, bs, hidden_dim]\n",
    "        x = seq_output[:, -1, :]\n",
    "        # 取最后一个时间步的输出 (这也是为什么要设置padding_first=True的原因)\n",
    "        x = self.layer(x)\n",
    "        x = self.fc(x)\n",
    "        return x\n",
    "    \n",
    "sample_inputs = torch.randint(0, vocab_size, (2, 128))\n",
    "    \n",
    "print(\"{:=^80}\".format(\" 一层单向 LSTM \"))       \n",
    "for key, value in LSTM().named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n",
    "\n",
    "    \n",
    "print(\"{:=^80}\".format(\" 一层双向 LSTM \"))       \n",
    "for key, value in LSTM(bidirectional=True).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n",
    "\n",
    "    \n",
    "print(\"{:=^80}\".format(\" 两层单向 LSTM \"))       \n",
    "for key, value in LSTM(num_layers=2).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-05-02T08:33:48.336669800Z",
     "start_time": "2024-05-02T08:33:48.283700100Z"
    },
    "execution": {
     "iopub.status.busy": "2024-05-03T04:47:42.947030Z",
     "iopub.execute_input": "2024-05-03T04:47:42.947353Z",
     "iopub.status.idle": "2024-05-03T04:47:42.981775Z",
     "shell.execute_reply.started": "2024-05-03T04:47:42.947327Z",
     "shell.execute_reply": "2024-05-03T04:47:42.980874Z"
    },
    "trusted": true
   },
   "execution_count": 11,
   "outputs": [
    {
     "name": "stdout",
     "text": "================================== 一层单向 LSTM ===================================\n            embeding.weight             paramerters num: 160000\n           lstm.weight_ih_l0            paramerters num: 4096\n           lstm.weight_hh_l0            paramerters num: 16384\n            lstm.bias_ih_l0             paramerters num: 256\n            lstm.bias_hh_l0             paramerters num: 256\n              layer.weight              paramerters num: 4096\n               layer.bias               paramerters num: 64\n               fc.weight                paramerters num: 64\n                fc.bias                 paramerters num: 1\n================================== 一层双向 LSTM ===================================\n            embeding.weight             paramerters num: 160000\n           lstm.weight_ih_l0            paramerters num: 4096\n           lstm.weight_hh_l0            paramerters num: 16384\n            lstm.bias_ih_l0             paramerters num: 256\n            lstm.bias_hh_l0             paramerters num: 256\n       lstm.weight_ih_l0_reverse        paramerters num: 4096\n       lstm.weight_hh_l0_reverse        paramerters num: 16384\n        lstm.bias_ih_l0_reverse         paramerters num: 256\n        lstm.bias_hh_l0_reverse         paramerters num: 256\n              layer.weight              paramerters num: 8192\n               layer.bias               paramerters num: 64\n               fc.weight                paramerters num: 64\n                fc.bias                 paramerters num: 1\n================================== 两层单向 LSTM ===================================\n            embeding.weight             paramerters num: 160000\n           lstm.weight_ih_l0            paramerters num: 4096\n           lstm.weight_hh_l0            paramerters num: 16384\n            lstm.bias_ih_l0             paramerters num: 256\n            lstm.bias_hh_l0             paramerters num: 256\n           lstm.weight_ih_l1            paramerters num: 16384\n           lstm.weight_hh_l1            paramerters num: 16384\n            lstm.bias_ih_l1             paramerters num: 256\n            lstm.bias_hh_l1             paramerters num: 256\n              layer.weight              paramerters num: 4096\n               layer.bias               paramerters num: 64\n               fc.weight                paramerters num: 64\n                fc.bias                 paramerters num: 1\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "4 * 16 * 64 #lstm.weight_ih_l0"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-05-02T08:36:09.545313600Z",
     "start_time": "2024-05-02T08:36:09.506335700Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "execution": {
     "iopub.status.busy": "2024-05-03T04:47:42.982885Z",
     "iopub.execute_input": "2024-05-03T04:47:42.983224Z",
     "iopub.status.idle": "2024-05-03T04:47:42.989768Z",
     "shell.execute_reply.started": "2024-05-03T04:47:42.983190Z",
     "shell.execute_reply": "2024-05-03T04:47:42.988745Z"
    },
    "trusted": true
   },
   "execution_count": 12,
   "outputs": [
    {
     "execution_count": 12,
     "output_type": "execute_result",
     "data": {
      "text/plain": "4096"
     },
     "metadata": {}
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "4* 64*64 #lstm.weight_hh_l0"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-05-02T08:36:14.836046500Z",
     "start_time": "2024-05-02T08:36:14.799050900Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "execution": {
     "iopub.status.busy": "2024-05-03T04:47:42.991003Z",
     "iopub.execute_input": "2024-05-03T04:47:42.991308Z",
     "iopub.status.idle": "2024-05-03T04:47:42.998461Z",
     "shell.execute_reply.started": "2024-05-03T04:47:42.991280Z",
     "shell.execute_reply": "2024-05-03T04:47:42.997549Z"
    },
    "trusted": true
   },
   "execution_count": 13,
   "outputs": [
    {
     "execution_count": 13,
     "output_type": "execute_result",
     "data": {
      "text/plain": "16384"
     },
     "metadata": {}
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 训练"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        # 二分类\n",
    "        preds = logits > 0\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-05-03T04:47:42.999576Z",
     "iopub.execute_input": "2024-05-03T04:47:42.999917Z",
     "iopub.status.idle": "2024-05-03T04:47:43.091789Z",
     "shell.execute_reply.started": "2024-05-03T04:47:42.999882Z",
     "shell.execute_reply": "2024-05-03T04:47:43.091056Z"
    },
    "trusted": true
   },
   "execution_count": 14,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "### TensorBoard 可视化\n",
    "\n",
    "\n",
    "训练过程中可以使用如下命令启动tensorboard服务。\n",
    "\n",
    "```shell\n",
    "tensorboard \\\n",
    "    --logdir=runs \\     # log 存放路径\n",
    "    --host 0.0.0.0 \\    # ip\n",
    "    --port 8848         # 端口\n",
    "```"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-05-03T04:47:43.092913Z",
     "iopub.execute_input": "2024-05-03T04:47:43.093218Z",
     "iopub.status.idle": "2024-05-03T04:47:43.118190Z",
     "shell.execute_reply.started": "2024-05-03T04:47:43.093169Z",
     "shell.execute_reply": "2024-05-03T04:47:43.117453Z"
    },
    "trusted": true
   },
   "execution_count": 15,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Save Best\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-05-03T04:47:43.119248Z",
     "iopub.execute_input": "2024-05-03T04:47:43.119557Z",
     "iopub.status.idle": "2024-05-03T04:47:43.129100Z",
     "shell.execute_reply.started": "2024-05-03T04:47:43.119532Z",
     "shell.execute_reply": "2024-05-03T04:47:43.128085Z"
    },
    "trusted": true
   },
   "execution_count": 16,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Early Stop"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-05-03T04:47:43.130506Z",
     "iopub.execute_input": "2024-05-03T04:47:43.130817Z",
     "iopub.status.idle": "2024-05-03T04:47:43.140541Z",
     "shell.execute_reply.started": "2024-05-03T04:47:43.130781Z",
     "shell.execute_reply": "2024-05-03T04:47:43.139593Z"
    },
    "trusted": true
   },
   "execution_count": 17,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits > 0\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 20\n",
    "\n",
    "model = LSTM()\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失 (但是二分类)\n",
    "loss_fct = F.binary_cross_entropy_with_logits\n",
    "# 2. 定义优化器 采用 adam\n",
    "# Optimizers specified in the torch.optim package\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/imdb-lstm\")\n",
    "# tensorboard_callback.draw_model(model, [1, MAX_LENGTH])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/imdb-lstm\", save_step=len(train_dl), save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=10)\n",
    "\n",
    "\n",
    "# 如果有可用的多个GPU\n",
    "if torch.cuda.device_count() > 1:\n",
    "    print(\"使用多个GPU进行训练...\")\n",
    "    model = nn.DataParallel(model)\n",
    "\n"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-05-03T04:54:24.950450Z",
     "iopub.execute_input": "2024-05-03T04:54:24.950804Z",
     "iopub.status.idle": "2024-05-03T04:54:24.977089Z",
     "shell.execute_reply.started": "2024-05-03T04:54:24.950774Z",
     "shell.execute_reply": "2024-05-03T04:54:24.975975Z"
    },
    "trusted": true
   },
   "execution_count": 23,
   "outputs": [
    {
     "name": "stdout",
     "text": "使用多个GPU进行训练...\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "model = model.to(device)\n",
    "start=time.time()\n",
    "record = training(\n",
    "    model, \n",
    "    train_dl, \n",
    "    test_dl, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=tensorboard_callback,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    "    )\n",
    "end=time.time()\n",
    "print(f'use time{end-start}')"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-05-03T04:54:24.979048Z",
     "iopub.execute_input": "2024-05-03T04:54:24.979327Z",
     "iopub.status.idle": "2024-05-03T05:00:05.269716Z",
     "shell.execute_reply.started": "2024-05-03T04:54:24.979303Z",
     "shell.execute_reply": "2024-05-03T05:00:05.268645Z"
    },
    "trusted": true
   },
   "execution_count": 24,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "  0%|          | 0/3920 [00:00<?, ?it/s]",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "85b715aace66444392bbc73bc0c23f52"
      }
     },
     "metadata": {}
    },
    {
     "name": "stdout",
     "text": "use time340.28171706199646\n",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        # axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        # axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=10)  #横坐标是 steps"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-05-03T05:00:05.271206Z",
     "iopub.execute_input": "2024-05-03T05:00:05.271603Z",
     "iopub.status.idle": "2024-05-03T05:00:05.708694Z",
     "shell.execute_reply.started": "2024-05-03T05:00:05.271566Z",
     "shell.execute_reply": "2024-05-03T05:00:05.707685Z"
    },
    "trusted": true
   },
   "execution_count": 25,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "<Figure size 1000x500 with 2 Axes>",
      "image/png": "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"
     },
     "metadata": {}
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "# 评估"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/imdb-lstm/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, test_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "metadata": {
    "execution": {
     "iopub.status.busy": "2024-05-03T05:00:05.710681Z",
     "iopub.execute_input": "2024-05-03T05:00:05.710984Z",
     "iopub.status.idle": "2024-05-03T05:00:13.257731Z",
     "shell.execute_reply.started": "2024-05-03T05:00:05.710959Z",
     "shell.execute_reply": "2024-05-03T05:00:13.256682Z"
    },
    "trusted": true
   },
   "execution_count": 26,
   "outputs": [
    {
     "name": "stdout",
     "text": "loss:     0.3319\naccuracy: 0.8690\n",
     "output_type": "stream"
    }
   ]
  }
 ]
}
